home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / c4.puma < prev    next >
Text File  |  1992-11-24  |  19KB  |  675 lines
  1. /* Ich, Doktor Josef Grosch, Informatiker, 18.12.1990 */
  2.  
  3. TRAFO EvalC2
  4. TREE Tree
  5. PUBLIC EvalImplC
  6.  
  7. GLOBAL {
  8.  
  9. FROM SYSTEM    IMPORT ADR;
  10. FROM IO        IMPORT WriteS, WriteNl, WriteI, StdOutput;
  11. FROM StringMem    IMPORT WriteString;
  12. FROM Idents    IMPORT tIdent, WriteIdent;
  13. FROM Texts    IMPORT WriteText;
  14. FROM Sets    IMPORT tSet, MakeSet, ReleaseSet, Include, Minimum, IsElement, WriteSet;
  15. FROM Relations    IMPORT IsRelated;
  16. FROM TreeC2    IMPORT WriteLine;
  17. FROM EvalC    IMPORT EvalImplHead;
  18.  
  19. FROM Tree    IMPORT
  20.    NoTree    , tTree        , Referenced    , NoCodeClass    ,
  21.    Computed    , Reverse    , Write        , Read        ,
  22.    Inherited    , Synthesized    , Input        , Output    ,
  23.    Stack    , Parameter    , Variable    ,
  24.    CopyDef    , CopyUse    , Thread    , Virtual    ,
  25.    Test        , Left        , Right        , NonBaseComp    ,
  26.    First    , Dummy        , Trace        , ClassCount    ,
  27.    Demand    , Funct        , NoClass    , Options    ,
  28.    TreeRoot    , iModule    , iMain        , itTree    ,
  29.    ForallClasses, ForallAttributes, f        , WI    , WN    ,
  30.    IdentifyAttribute, GrammarClass, cOAG    , MaxVisit    ,
  31.    WriteInstance;
  32.  
  33. VAR
  34.    Start, Stop, Visit, ChildVisit, i, j, k    : SHORTCARD;
  35.    Node, Attr, Class, AttrClass, Child, Child2, ChildsClass    : tTree;
  36.  
  37. PROCEDURE Representative (i: CARDINAL): CARDINAL;    (* Class    *)
  38.    VAR
  39.       s        : tSet;
  40.       r        : CARDINAL;
  41.       Stable    : BOOLEAN;
  42.       j, k    : CARDINAL;
  43.    BEGIN
  44.       WITH Class^.Class DO
  45.      MakeSet (s, InstCount);
  46.      Include (s, i);
  47.      REPEAT
  48.         Stable := TRUE;
  49.         FOR j := 1 TO InstCount DO
  50.            IF IsElement (j, s) THEN
  51.           IF CopyDef IN Instance^[j].Properties THEN
  52.              k := Instance^[j].CopyArg;
  53.              IF (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  54.             NOT IsElement (k, s) THEN
  55.             Include (s, k);
  56.             Stable := FALSE;
  57.              END;
  58.           END;
  59.           IF CopyUse IN Instance^[j].Properties THEN
  60.              FOR k := 1 TO InstCount DO
  61.             IF (CopyDef IN Instance^[k].Properties) AND
  62.                (Parameter IN Instance^[k].Attribute^.Attribute.Properties) AND
  63.                (Instance^[k].CopyArg = j) AND
  64.                NOT IsElement (k, s) THEN
  65.                Include (s, k);
  66.                Stable := FALSE;
  67.             END;
  68.              END;
  69.           END;
  70.            END;
  71.         END;
  72.      UNTIL Stable;
  73.      r := Minimum (s);
  74.      IF r <= AttrCount THEN
  75.         Stable := TRUE;
  76.         j := r + 1;
  77.         LOOP
  78.            IF j > AttrCount THEN EXIT; END;
  79.            IF IsElement (j, s) THEN Stable := FALSE; EXIT; END;
  80.            INC (j);
  81.         END;
  82.         IF NOT Stable THEN
  83.            j := 1;
  84.            LOOP
  85.           k := Instance^ [j].Order;
  86.           IF (k <= AttrCount) AND IsElement (k, s) THEN r := k; EXIT; END;
  87.           INC (j);
  88.            END;
  89.         END;
  90.      END;
  91.      ReleaseSet (s);
  92.      RETURN r;
  93.       END;
  94.    END Representative;
  95.  
  96. PROCEDURE GenAttribute (i: CARDINAL; repr: BOOLEAN);    (* Class = subtype, Node = current type, k    *)
  97.    BEGIN
  98.       IF repr THEN
  99.      WITH Class^.Class.Instance^[i] DO
  100.         IF (Parameter IN Attribute^.Attribute.Properties) AND
  101.            (({CopyDef, CopyUse} * Properties) # {}) THEN
  102.            i := Representative (i);
  103.         END;
  104.      END;
  105.       END;
  106.       WITH Class^.Class.Instance^[i] DO
  107.      IF Virtual IN Properties THEN RETURN; END;
  108.      IF Left IN Properties THEN                    (* left        *)
  109.         WITH Attribute^.Attribute DO
  110.            IF Parameter IN Properties THEN
  111.           IF IdentifyAttribute (Node, Name) = NoTree THEN
  112.              !yy! WI (Name);                    (* local    *)
  113.           ELSE
  114.              !(* yy! WI (Name); !)!                (* param    *)
  115.           END;
  116.            ELSIF Demand IN Properties THEN                (* demand    *)
  117.           IF Funct IN Properties THEN
  118.              AttrClass := GetClass (Class, Name);        (* function    *)
  119.              !y! WI (AttrClass^.Class.Name); !y! WI (Name); ! (yyt)! 
  120.           ELSIF i # k THEN
  121.              !yy! WI (Name);                    (* local    *)
  122.           ELSE
  123.              !(* yy! WI (Name); !)!                (* param    *)
  124.           END;
  125.            ELSE                            (* tree        *)
  126.           !yyt->! WI (Class^.Class.Name); !.! WI (Name);
  127.            END;
  128.         END;
  129.      ELSE                                (* right    *)
  130.         WITH Attribute^.Attribute DO
  131.            IF Parameter IN Properties THEN
  132.           WI (Selector^.Child.Name); !yy! WI (Name);        (* param    *)
  133.            ELSIF Demand IN Properties THEN                (* demand    *)
  134.           IF Funct IN Properties THEN            (* function    *)
  135.              AttrClass := GetClass (Selector^.Child.Class, Name);
  136.              !y! WI (AttrClass^.Class.Name); !y! WI (Name);
  137.              ! (yyt->! WI (Class^.Class.Name); !.! WI (Selector^.Child.Name); !)! 
  138.           ELSE
  139.              WI (Selector^.Child.Name); !yy! WI (Name);
  140.           END;
  141.            ELSE                            (* tree        *)
  142.           !yyt->! WI (Class^.Class.Name); !.! WI (Selector^.Child.Name);
  143.           !->! WI (Selector^.Child.Type); !.! WI (Name);
  144.            END;
  145.         END;
  146.      END;
  147.       END;
  148.    END GenAttribute;
  149.  
  150. PROCEDURE GetClass (Class: tTree; Attribute: tIdent): tTree;
  151.    BEGIN
  152.       WHILE Class^.Kind # NoClass DO
  153.      IF IdentifyAttribute (Class^.Class.Attributes, Attribute) # NoTree THEN RETURN Class; END;
  154.      Class := Class^.Class.BaseClass;
  155.       END;
  156.       RETURN NoTree;
  157.    END GetClass;
  158.  
  159. PROCEDURE CheckUsage (Usage: BITSET): BOOLEAN;    (* Class, Child, Start, Stop    *)
  160.    VAR i, i2: SHORTCARD;
  161.    BEGIN
  162.       FOR i := Start TO Stop DO
  163.      i2 := Class^.Class.Instance^ [i].Order;
  164.      WITH Class^.Class.Instance^ [i2] DO
  165.         IF ({Synthesized, Right, First} <= Properties) AND
  166.            (Child = Selector) AND
  167.            (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) AND
  168.            (Attribute^.Child.Partition IN Usage) THEN
  169.            RETURN TRUE;
  170.         END;
  171.         IF ({Inherited, Right} <= Properties) AND (i2 = j) THEN
  172.            RETURN TRUE;
  173.         END;
  174.      END;
  175.       END;
  176.       RETURN FALSE;
  177.    END CheckUsage;
  178. }
  179.  
  180. BEGIN    { k := 0; }
  181.  
  182. PROCEDURE EvalImplC (t: Tree)
  183.     
  184. Ag (..) :- {
  185.     EvalImplHead (t);
  186.     !!
  187.     ForallClasses (Classes, Forward);
  188.     !!
  189.     !void ! WI (EvalName); !!
  190.     !# if defined __STDC__ | defined __cplusplus!
  191.     ! (! WI (itTree); ! yyt)!
  192.     !# else!
  193.     ! (yyt) ! WI (itTree); ! yyt;!
  194.     !# endif!
  195.     Node := Classes;
  196.     Class := Classes;
  197.     !{!
  198.     ForallAttributes (Class, GenTemposLocal);
  199.       IF NOT IsElement (ORD ('9'), Options) THEN
  200.     IF MaxVisit > 0 THEN
  201.        Class := Classes;
  202.        Visit := 1;
  203.        ! yyVisit1! WI (Class^.Class.Name); ! (yyt! 
  204.        ForallAttributes (Class, GenActualsLeft);
  205.        !);! 
  206.     END;
  207.     ! }!
  208.       ELSE
  209.     ! char xxHigh;!
  210.     ! xxStack = 1000000000;!
  211.     IF MaxVisit > 0 THEN
  212.        Class := Classes;
  213.        Visit := 1;
  214.        ! yyVisit1! WI (Class^.Class.Name); ! (yyt! 
  215.        ForallAttributes (Class, GenActualsLeft);
  216.        !);!
  217.     END;
  218.     @ (void) printf ("Stacksize %d\n", (int) & xxHigh - xxStack);@
  219.     !}!
  220.       END;
  221.     !!
  222.     ForallClasses (Classes, GenDemandProc);
  223.     ForallClasses (Classes, EvalImplC);
  224.     !void Begin! WI (EvalName); ! ()!
  225.     !{!
  226.     WriteLine (EvalCodes^.Codes.BeginLine);
  227.     WriteText (f, EvalCodes^.Codes.Begin);
  228.     Node := Modules;
  229.     WHILE Node^.Kind = Tree.Module DO
  230.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  231.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  232.        Node := Node^.Module.Next;
  233.     END;
  234.     !}!
  235.     !!
  236.     !void Close! WI (EvalName); ! ()!
  237.     !{!
  238.     WriteLine (EvalCodes^.Codes.CloseLine);
  239.     WriteText (f, EvalCodes^.Codes.Close);
  240.     Node := Modules;
  241.     WHILE Node^.Kind = Tree.Module DO
  242.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  243.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  244.        Node := Node^.Module.Next;
  245.     END;
  246.     !}!
  247. }; .
  248. Class (..) :- {
  249.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  250.     IF Referenced IN Properties THEN
  251.        Generated := 0;
  252.        ForallClasses (Extensions, Generated0);
  253.        FOR Visit := 1 TO Visits DO
  254.           Node := t;
  255.           Class := t;
  256.           !static void yyVisit! WN (Visit); WI (Name); !!
  257.           !# if defined __STDC__ | defined __cplusplus!
  258.           ! (register ! WI (itTree); ! yyt! ForallAttributes (t, GenFormals3); !)!
  259.           !# else!
  260.           ! (yyt! ForallAttributes (t, GenFormals1); !)!
  261.           ! register ! WI (itTree); ! yyt;!
  262.           ForallAttributes (t, GenFormals2);
  263.           !# endif!
  264.           !{!
  265.           WriteLine (TreeRoot^.Ag.EvalCodes^.Codes.LocalLine);
  266.           WriteText (f, TreeRoot^.Ag.EvalCodes^.Codes.Local);
  267.           Node := TreeRoot^.Ag.Modules;
  268.           WHILE Node^.Kind = Tree.Module DO
  269.          WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  270.          WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  271.          Node := Node^.Module.Next;
  272.           END;
  273.       IF IsElement (ORD ('9'), Options) THEN
  274.           ! char xxLow;!
  275.           ! xxStack = Min (xxStack, (int) & xxLow);!
  276.       END;
  277.           ! switch (yyt->Kind) {!
  278.           IF cOAG IN GrammarClass THEN        (* generate evaluator    *)
  279.          Node := t;
  280.          GenEvaluator (t);
  281.          ForallClasses (Extensions, GenEvaluator);
  282.           END;
  283.           ! default: ;!
  284.       IF IsElement (ORD ('Z'), Options) THEN
  285.           !  yyVisitParent (yyt);!
  286.       END;
  287.           ! }!
  288.           !}!
  289.           !!
  290.        END;
  291.     END;
  292. }; .
  293.  
  294.  
  295. PROCEDURE TypeName (t: Tree)
  296.  
  297. Class (..) :- {
  298.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  299.     IF Trace IN Properties THEN
  300.        @"@ WI (Name); @",@
  301.     END;
  302. }; .
  303.  
  304.  
  305. PROCEDURE Forward        /* Node, Class (sometimes)    */ (t: Tree)
  306.  
  307. Class (..) :- {
  308.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  309.     IF Referenced IN Properties THEN
  310.        FOR Visit := 1 TO Visits DO
  311.           !static void yyVisit! WN (Visit); WI (Name); ! ARGS((register ! WI (itTree); ! yyt! 
  312.           Node := t;
  313.           Class := t;
  314.           ForallAttributes (t, Forward);
  315.           !));!
  316.        END;
  317.     END;
  318. }; .
  319. Attribute (..) :- {
  320.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  321.        !, ! WI (Type); ! ! GenAttribute (AttrIndex, FALSE);
  322.     END;
  323. }; .
  324.  
  325.  
  326. PROCEDURE GenEvaluator    /* Node, Class (sometimes), Visit    */ (t: Tree)
  327.  
  328. Class (..) :- {
  329.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  330.     IF Generated = InstCount THEN RETURN; END;
  331.     !case k! WI (Name); !: {!
  332.  
  333.     Start := Generated + 1;
  334.     LOOP
  335.        IF Generated = InstCount THEN EXIT; END;
  336.        INC (Generated);
  337.        WITH Instance^ [Instance^ [Generated].Order] DO
  338.           IF (Left IN Properties) AND (Attribute^.Child.Partition > Visit) THEN
  339.              DEC (Generated); EXIT;
  340.           END;
  341.        END;
  342.     END;
  343.     Stop := Generated;
  344.  
  345.     Class := t;
  346.     ForallAttributes (t, GenTempos);
  347.  
  348.     FOR Start := Start TO Stop DO
  349.        i := Instance^ [Start].Order;
  350.        WITH Instance^ [i] DO
  351.           IF ({Inherited, Right, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  352.          GenDemandEval (t);
  353.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  354.          @yyWriteEval (yyt, "@ WI (Selector^.Child.Name); !:! WI (Attribute^.Child.Name); @");@
  355.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; !!
  356.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  357.             !write! WI (itTree); ! (! GenAttribute (i, TRUE); !)!
  358.          ELSE
  359.             !write! WI (Attribute^.Child.Type); ! (! GenAttribute (i, TRUE); !) yyWriteNl ();!
  360.          END;
  361.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  362.          @yyWriteEval (yyt, "@ WI (Selector^.Child.Name); !:! WI (Attribute^.Child.Name); @");@
  363.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  364.       ELSE
  365.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  366.       END;
  367.           END;
  368.           IF ({Synthesized, Left, First} <= Properties) AND ({Dummy, Virtual, Demand} * Properties = {}) THEN
  369.          GenDemandEval (t);
  370.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  371.          @yyWriteEval (yyt, "@ WI (Attribute^.Child.Name); @");@
  372.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; !!
  373.          IF Test IN Properties THEN
  374.             !writebool (yyb) yyWriteNl ();!
  375.          ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  376.             !write! WI (itTree); ! (! GenAttribute (i, TRUE); !)!
  377.          ELSE
  378.             !write! WI (Attribute^.Child.Type); ! (! GenAttribute (i, TRUE); !) yyWriteNl ();!
  379.          END;
  380.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  381.          @yyWriteEval (yyt, "@ WI (Attribute^.Child.Name); @");@
  382.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  383.       ELSE
  384.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  385.       END;
  386.           END;
  387.           IF ({Synthesized, Right, First} <= Properties) AND
  388.          (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) THEN
  389.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  390.          @yyWriteVisit (yyt, "@ WI (Selector^.Child.Name); ! ! 
  391.          WN (Attribute^.Child.Partition); @");@
  392.       END;
  393.          ChildVisit := Attribute^.Child.Partition;
  394.          Child := Selector;
  395.          !yyVisit! WN (ChildVisit); WI (Child^.Child.Type);
  396.          ! (yyt->! WI (Name); !.! WI (Child^.Child.Name);
  397.          ForallAttributes (Child^.Child.Class, GenActualsRight);
  398.          !);!
  399.           END;
  400.        END;
  401.     END;
  402.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  403.     !yyVisitParent (yyt);!
  404.       END;
  405.     !} break;!
  406. }; .
  407. Assign (..) :- {
  408.     WriteLine (Pos);
  409.     GenEvaluator (Results); !=! GenEvaluator (Arguments); !;!
  410. }; .
  411. Copy (..) :- {
  412.     j := Class^.Class.Instance^[i].CopyArg;
  413.     IF (Parameter IN Class^.Class.Instance^[i].Attribute^.Attribute.Properties) AND
  414.        (Parameter IN Class^.Class.Instance^[j].Attribute^.Attribute.Properties) THEN
  415.        IF (Left IN Class^.Class.Instance^[i].Properties) AND
  416.           (Left IN Class^.Class.Instance^[j].Properties) THEN
  417.  
  418.           WriteLine (Pos);
  419.           GenAttribute (i, FALSE); ! =! GenEvaluator (Arguments); !;!
  420.        END;
  421.     ELSE
  422.        WriteLine (Pos);
  423.        GenEvaluator (Results); !=! GenEvaluator (Arguments); !;!
  424.     END;
  425. }; .
  426. TargetCode (..) :- {
  427.     WriteLine (Pos);
  428.     GenEvaluator (Code); !!
  429. }; .
  430. Check (..) :- {
  431.     WriteLine (Pos);
  432.     IF Condition # NoTree THEN
  433.        @if (! (@ 
  434.       IF IsElement (ORD ('X'), Options) THEN
  435.        !yyb = ! 
  436.       END;
  437.        GenEvaluator (Condition); !)) {! GenEvaluator (Statement); !; }!
  438.        IF Actions^.Kind = Tree.Check THEN
  439.           !else ! GenEvaluator (Actions);
  440.        END;
  441.     ELSE
  442.       IF IsElement (ORD ('X'), Options) THEN
  443.        !yyb = false; ! 
  444.       END;
  445.        GenEvaluator (Statement); !;!
  446.        GenEvaluator (Actions);
  447.     END;
  448. }; .
  449. Designator (..) :- {
  450.     Child2 := IdentifyAttribute (Class, Selector);
  451.     IF Child2 # NoTree THEN
  452.        ChildsClass := Child2^.Child.Class;
  453.        Attr := IdentifyAttribute (ChildsClass, Attribute);
  454.        IF Attr # NoTree THEN
  455.           GenAttribute (Class^.Class.AttrCount + Child2^.Child.InstOffset + Attr^.Attribute.AttrIndex, TRUE);
  456.        ELSE
  457.           WI (Selector); !:! WI (Attribute);
  458.        END;
  459.     ELSE
  460.        WI (Selector); !:! WI (Attribute);
  461.     END;
  462.     GenEvaluator (Next);
  463. }; .
  464. Ident (..) :- {
  465.     Attr := IdentifyAttribute (Class, Attribute);
  466.     IF Attr # NoTree THEN
  467.        GenAttribute (Attr^.Attribute.AttrIndex, TRUE);
  468.     ELSE
  469.        WI (Attribute);
  470.     END;
  471.     GenEvaluator (Next);
  472. }; .
  473. Any (..) :- {
  474.     WriteString (f, Code);
  475.     GenEvaluator (Next);
  476. }; .
  477. Anys (..) :- {
  478.     GenEvaluator (Layouts);
  479.     GenEvaluator (Next);
  480. }; .
  481. LayoutAny (..) :- {
  482.     WriteString (f, Code);
  483.     GenEvaluator (Next);
  484. }; .
  485.  
  486.  
  487. PROCEDURE Generated0 (t: Tree)
  488.  
  489. Class (..) :- {
  490.     Generated := 0;
  491. }; .
  492.  
  493.  
  494. PROCEDURE GenFormals1    /* Node, Class, Visit    */ (t: Tree)
  495.  
  496. Attribute (..) :- {
  497.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  498.        !, yy! WI (Name);
  499.     END;
  500. }; .
  501.  
  502.  
  503. PROCEDURE GenFormals2    /* Node, Class, Visit    */ (t: Tree)
  504.  
  505. Attribute (..) :- {
  506.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  507.        ! ! WI (Type); ! ! GenAttribute (AttrIndex, FALSE); !;!
  508.     END;
  509. }; .
  510.  
  511.  
  512. PROCEDURE GenFormals3    /* Node, Class, Visit    */ (t: Tree)
  513.  
  514. Attribute (..) :- {
  515.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  516.        ! ,! WI (Type); ! ! GenAttribute (AttrIndex, FALSE);
  517.     END;
  518. }; .
  519.  
  520.  
  521. PROCEDURE GenActualsRight    /* Node = current type, Class = subtype, Child, ChildVisit    */ (t: Tree)
  522.  
  523. Attribute (..) :- {
  524.     IF (Parameter IN Properties) AND (ChildVisit IN Usage) THEN
  525.        !, & ! GenAttribute (Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex, TRUE);
  526.     END;
  527. }; .
  528.  
  529.  
  530. PROCEDURE GenActualsLeft    /* Node = current type, Class = subtype, Visit    */ (t: Tree)
  531.  
  532. Attribute (..) :- {
  533.     IF (Parameter IN Properties) AND (Visit IN Usage) THEN
  534.        !, ! GenAttribute (AttrIndex, FALSE);
  535.     END;
  536. }; .
  537.  
  538.  
  539. PROCEDURE GenTempos    /* Node, Class (sometimes), Visit, k    */ (t: Tree)
  540.  
  541. Child (..) :- {
  542.     Child := t;
  543.     ForallAttributes (Class, GenTemposChildren);
  544. }; .
  545. Attribute (..) :- {
  546.     IF (Parameter IN Properties) AND (IdentifyAttribute (Node, Name) = NoTree) AND (Visit IN Usage) OR
  547.        (Demand IN Properties) AND NOT (Funct IN Properties) AND (AttrIndex # k) THEN
  548.        WI (Type); ! yy! WI (Name); !;!
  549.     END;
  550. }; .
  551.  
  552.  
  553. PROCEDURE GenTemposChildren    /* Node, Class, Child    */ (t: Tree)
  554.  
  555. Attribute (..) :- {
  556.     IF (Parameter IN Properties) OR
  557.        (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  558.        j := Class^.Class.AttrCount + Child^.Child.InstOffset + AttrIndex;
  559.        IF (Demand IN Properties) OR
  560.           (({CopyDef, CopyUse} * Class^.Class.Instance^[j].Properties) = {}) OR
  561.           (j = Representative (j)) THEN
  562.           IF CheckUsage (Usage) THEN
  563.          WI (Type); ! ! WI (Child^.Child.Name); !yy! WI (Name); !;!
  564.           END;
  565.        END;
  566.     END;
  567. }; .
  568.  
  569.  
  570. PROCEDURE GenTemposLocal    /* Node, Class    */ (t: Tree)
  571.  
  572. Attribute (..) :- {
  573.     IF Parameter IN Properties THEN
  574.        !  ! WI (Type); ! ! GenAttribute (AttrIndex, FALSE); !;!
  575.     END;
  576. }; .
  577.  
  578.  
  579. PROCEDURE GenDemandProc    /* Node, Class    */ (t: Tree)
  580.  
  581. Class (..) :- {
  582.     IF (NoCodeClass * Properties) # {} THEN RETURN; END;
  583.     Node := t;
  584.     ForallAttributes (Attributes, GenDemandProc);
  585. }; .
  586. Attribute (..) :- {
  587.     IF Demand IN Properties THEN
  588.        Class := Node;
  589.        k := AttrIndex;
  590.        IF Funct IN Properties THEN
  591.           !static ! WI (Type); ! y! WI (Class^.Class.Name); !y! WI (Name); !!
  592.           !# if defined __STDC__ | defined __cplusplus!
  593.           ! (register ! WI (itTree); ! yyt)!
  594.           !# else!
  595.           ! (yyt) register ! WI (itTree); ! yyt;!
  596.           !# endif!
  597.        ELSE
  598.           !static void y! WI (Class^.Class.Name); !y! WI (Name); !!
  599.           !# if defined __STDC__ | defined __cplusplus!
  600.           ! (register ! WI (itTree); ! yyt, ! WI (Type); ! * ! GenAttribute (AttrIndex, FALSE); !)!
  601.           !# else!
  602.           ! (yyt, ! GenAttribute (AttrIndex, FALSE); !)!
  603.           ! register ! WI (itTree); ! yyt;!
  604.           ! ! WI (Type); ! * ! GenAttribute (AttrIndex, FALSE); !;!
  605.           !# endif!
  606.        END;
  607.        !{!
  608.        ! switch (yyt->Kind) {!
  609.        IF cOAG IN GrammarClass THEN
  610.           i := AttrIndex;
  611.           Class := Node;
  612.           Visit := Partition;
  613.           GenDemandProc2 (Class);
  614.           ForallClasses (Class^.Class.Extensions, GenDemandProc2);
  615.           Class := Node;
  616.        END;
  617.        ! default: ;!
  618.        ! }!
  619.        !}!
  620.        !!
  621.        k := 0;
  622.     END;
  623. }; .
  624.  
  625.  
  626. PROCEDURE GenDemandProc2    /* Node, Class, i, Visit    */ (t: Tree)
  627.  
  628. Class (..) :- {
  629.     !case k! WI (Name); !: {!
  630.     WITH Instance^ [i] DO
  631.        Class := t;
  632.        ForallAttributes (t, GenTempos);
  633.        GenDemandEval (t);
  634.        IF Funct IN Properties THEN
  635.           GenDemandProc2 (Action);
  636.        ELSE
  637.           GenEvaluator (Action); !!
  638.        END;
  639.     END;
  640.     !} break;!
  641. }; .
  642. Assign (..) :- {
  643.     !return ! GenEvaluator (Arguments); !;!
  644. }; .
  645. Copy (..) :- {
  646.     !return ! GenEvaluator (Arguments); !;!
  647. }; .
  648. TargetCode (..) :- {
  649.     !NoBlockStatementForDemandFunctionAttributes;!
  650. }; .
  651.  
  652.  
  653. PROCEDURE GenDemandEval    /* Node, Class, i    */ (t: Tree)
  654.  
  655. Class (..) :- {
  656.     FOR j := 1 TO InstCount DO
  657.        WITH Instance^ [j] DO
  658.           IF IsRelated (i, j, DP) AND 
  659.          (Demand IN Properties) AND NOT (Funct IN Properties) THEN
  660.          IF Left IN Properties THEN
  661.             AttrClass := GetClass (t, Attribute^.Child.Name);
  662.             !    y! WI (AttrClass^.Class.Name); !y! WI (Attribute^.Child.Name);
  663.             ! (yyt, ! GenAttribute (j, FALSE); !);!
  664.          ELSE
  665.             AttrClass := GetClass (Selector^.Child.Class, Attribute^.Child.Name);
  666.             !    y! WI (AttrClass^.Class.Name); !y! WI (Attribute^.Child.Name);
  667.             ! (yyt->! WI (Name); !.! WI (Selector^.Child.Name);
  668.             !, ! GenAttribute (j, FALSE); !);!
  669.          END;
  670.           END;
  671.        END;
  672.     END;
  673. }; .
  674.  
  675.